Ship the field manual, not the Library of Congress

Models are usually shipped as one indivisible thing: a weight checkpoint plus a runtime. Convenient, and increasingly the wrong shape. Memory bandwidth dominates inference cost, runtime state becomes the bottleneck at long context, and "adapting to a domain" usually means cloning or editing whole weight tensors. If you want a model that stays current in a real business, re-shipping the entire brain every time a rule changes is absurd: that's shipping the Library of Congress when the reader needed one updated field manual.

A model is a signal chain

Look at what a transformer actually does and it resembles a predictive signal chain: information flows through a residual stream across layers, each applying incremental transforms that keep the predictive features and discard the rest. That's the logic of a perceptual codec: allocate bits by sensitivity, spend where it matters, drop where it doesn't. Framed that way, capability decomposes into a compressed carrier and a set of modular overlays, both governed by the same rate-distortion tradeoff.

Delta codes over a compressed base

The base model is the carrier: stable, broadly capable, often aggressively quantized. On top of it ride memory packs — Mempacks™: low-rate residual edits. A LoRA-style pack is literally a delta code: a low-rank BA update over a frozen weight, so a domain skill is a few megabytes, not a new checkpoint. Bit allocation follows sensitivity, the way a codec spends bits where perception is keenest: put the budget on the parameters the loss is most sensitive to.

Temporal packs, too

The same lens covers runtime memory. A KV cache is compressible, versionable state: evict the low-value tokens, quantize the rest, stream a compact encoding for reuse. Treat it as a temporal pack with an explicit encode/decode contract and it becomes another artifact you can budget, not an unbounded cost that grows with context length.

Composability isn't free

Here's the honest part. Deltas add by construction; behavior doesn't. Two skill packs trained on different domains can fight over the same predictive bandwidth, and the interference is measurable: it shows up as a cross-curvature term, negative synergy when the deltas overlap under the loss surface. So packs are not universally stackable. The answer is selective, compatibility-aware routing: activate only the few packs a context needs, and design them to be curvature-orthogonal where you can.

Packs behave like code

Because a pack is a modular artifact, it gets governed like one. Content-addressed by hash. Signed. Versioned against a specific base and tensor schema. Auditable for behavior and licensing. Activated under policy (per tenant, per domain, per safety regime) and rolled back without touching the base. A manifest says exactly what it edits:

{ "pack_id": "contracts-redlining-v1",
  "base_model": { "sha256": "…" },
  "targets": [ { "module": "layers.10.mlp.up_proj", "form": "lora", "rank": 16 } ],
  "eval": { "ppl": 7.23, "accuracy": 0.61 } }

That's the discipline: a stable base, plus small, signed, swappable overlays that carry only what changed, routed at inference and updated on a schedule. Ship the field manual, not the whole library. It isn't yet peer-reviewed, but the math holds, and our engine is built on it. The loop that builds, gates, and versions these packs is patent pending.